<html>
 <head>
  <meta charset="utf-8"/>
  <meta content="width=device-width, initial-scale=1, maximum-scale=1, user-scalable=no" name="viewport"/>
  <title>
   关联挖掘算法Apriori和FP-Tree学习，及算法实现  | 数螺 | NAUT IDEA
  </title>
  <link href="http://cdn.bootcss.com/bootstrap/3.3.6/css/bootstrap-theme.min.css" rel="stylesheet"/>
  <link href="http://cdn.bootcss.com/bootstrap/3.3.6/css/bootstrap.min.css" rel="stylesheet"/>
  <style type="text/css">
   #xmain img {
                  max-width: 100%;
                  display: block;
                  margin-top: 10px;
                  margin-bottom: 10px;
                }

                #xmain p {
                    line-height:150%;
                    font-size: 16px;
                    margin-top: 20px;
                }

                #xmain h2 {
                    font-size: 24px;
                }

                #xmain h3 {
                    font-size: 20px;
                }

                #xmain h4 {
                    font-size: 18px;
                }


                .header {
	           background-color: #0099ff;
	           color: #ffffff;
	           margin-bottom: 20px;
	        }

	        .header p {
                  margin: 0px;
                  padding: 10px 0;
                  display: inline-block;  
                  vertical-align: middle;
                  font-size: 16px;
               }

               .header a {
                 color: white;
               }

              .header img {
                 height: 25px;
              }
  </style>
  <script src="http://cdn.bootcss.com/jquery/3.0.0/jquery.min.js">
  </script>
  <script src="http://nautstatic-10007657.file.myqcloud.com/static/css/readability.min.js" type="text/javascript">
  </script>
  <script type="text/javascript">
   $(document).ready(function() {
                 var loc = document.location;
                 var uri = {
                  spec: "http://dataunion.org/16342.html",
                  host: "http://dataunion.org",
                  prePath: "http://dataunion.org",
                  scheme: "http",
                  pathBase: "http://dataunion.org/"
                 };
    
                 var documentClone = document.cloneNode(true);
                 var article = new Readability(uri, documentClone).parse();
     
                 document.getElementById("xmain").innerHTML = article.content;
                });
  </script>
  <!-- 1466459642: Accept with keywords: (title(0.6):挖掘,算法,社区,数盟,关联, topn(0.566666666667):结论,结点,复杂度,路径,数盟,集合,条件,数据挖掘,社区,项头,剪枝,后缀,数据库,元素,模式,子集,计算,文章,方法,节点,事务,关联,计数,算法,规则,挖掘,置信度,递归,数据,项集).-->
 </head>
 <body onload="">
  <div class="header">
   <div class="container">
    <div class="row">
     <div class="col-xs-6 col-sm-6 text-left">
      <a href="/databee">
       <img src="http://nautidea-10007657.cos.myqcloud.com/logo_white.png"/>
      </a>
      <a href="/databee">
       <p>
        数螺
       </p>
      </a>
     </div>
     <div class="hidden-xs col-sm-6 text-right">
      <p>
       致力于数据科学的推广和知识传播
      </p>
     </div>
    </div>
   </div>
  </div>
  <div class="container text-center">
   <h1>
    关联挖掘算法Apriori和FP-Tree学习，及算法实现
   </h1>
  </div>
  <div class="container" id="xmain">
   ﻿﻿
   <title>
    关联挖掘算法Apriori和FP-Tree学习，及算法实现 | 数盟社区
   </title>
   <!-- All in One SEO Pack 2.2.7.6.2 by Michael Torbert of Semper Fi Web Design[32,76] -->
   <!-- /all in one seo pack -->
   <!--
<div align="center">
<a href="http://strata.oreilly.com.cn/hadoop-big-data-cn?cmp=mp-data-confreg-home-stcn16_dataunion_pc" target="_blank"><img src="http://dataunion.org/wp-content/uploads/2016/05/stratabj.jpg"/ ></a>
</div>
-->
   <header id="header-web">
    <div class="header-main">
     <hgroup class="logo">
      <h1>
       <a href="http://dataunion.org/" rel="home" title="数盟社区">
        <img src="http://dataunion.org/wp-content/themes/yzipi/images/logo.png"/>
       </a>
      </h1>
     </hgroup>
     <!--logo-->
     <nav class="header-nav">
      <ul class="menu" id="menu-%e4%b8%bb%e8%8f%9c%e5%8d%95">
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-has-children menu-item-71" id="menu-item-71">
        <a href="http://dataunion.org/category/events" title="events">
         活动
        </a>
        <ul class="sub-menu">
         <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-22457" id="menu-item-22457">
          <a href="http://dataunion.org/2016timeline">
           2016档期
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-22459" id="menu-item-22459">
          <a href="http://dataunion.org/category/parterc">
           合作会议
          </a>
         </li>
        </ul>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category current-post-ancestor current-menu-parent current-post-parent menu-item-has-children menu-item-20869" id="menu-item-20869">
        <a href="http://dataunion.org/category/tech" title="articles">
         文章
        </a>
        <ul class="sub-menu">
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-20867" id="menu-item-20867">
          <a href="http://dataunion.org/category/tech/base" title="base">
           基础架构
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-3302" id="menu-item-3302">
          <a href="http://dataunion.org/category/tech/ai" title="ai">
           人工智能
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-3303" id="menu-item-3303">
          <a href="http://dataunion.org/category/tech/analysis" title="analysis">
           数据分析
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-21920" id="menu-item-21920">
          <a href="http://dataunion.org/category/tech/dm">
           数据挖掘
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-3314" id="menu-item-3314">
          <a href="http://dataunion.org/category/tech/viz" title="viz">
           可视化
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-3305" id="menu-item-3305">
          <a href="http://dataunion.org/category/tech/devl" title="devl">
           编程语言
          </a>
         </li>
        </ul>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-has-children menu-item-20876" id="menu-item-20876">
        <a href="http://dataunion.org/category/industry">
         行业
        </a>
        <ul class="sub-menu">
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-16328" id="menu-item-16328">
          <a href="http://dataunion.org/category/industry/case" title="case">
           行业应用
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-2112" id="menu-item-2112">
          <a href="http://dataunion.org/category/industry/demo" title="demo">
           Demo展示
          </a>
         </li>
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-21562" id="menu-item-21562">
          <a href="http://dataunion.org/category/industry/news">
           行业资讯
          </a>
         </li>
        </ul>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-311" id="menu-item-311">
        <a href="http://dataunion.org/category/sources" title="sources">
         资源
        </a>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-20870" id="menu-item-20870">
        <a href="http://dataunion.org/category/books" title="book">
         图书
        </a>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-21363" id="menu-item-21363">
        <a href="http://dataunion.org/category/training">
         课程
        </a>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-has-children menu-item-21853" id="menu-item-21853">
        <a href="http://dataunion.org/category/jobs">
         职位
        </a>
        <ul class="sub-menu">
         <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-22050" id="menu-item-22050">
          <a href="http://dataunion.org/category/career">
           职业规划
          </a>
         </li>
        </ul>
       </li>
      </ul>
     </nav>
     <!--header-nav-->
    </div>
   </header>
   <!--header-web-->
   <div id="main">
    <div id="soutab">
     <form action="http://dataunion.org/" class="search" method="get">
     </form>
    </div>
    <div id="container">
     <nav id="mbx">
      当前位置：
      <a href="http://dataunion.org">
       首页
      </a>
      &gt;
      <a href="http://dataunion.org/category/tech">
       文章
      </a>
      &gt;  正文
     </nav>
     <!--mbx-->
     <article class="content">
      <header align="centre" class="contenttitle">
       <div class="mscc">
        <h1 class="mscctitle">
         <a href="http://dataunion.org/16342.html">
          关联挖掘算法Apriori和FP-Tree学习，及算法实现
         </a>
        </h1>
        <address class="msccaddress ">
         <em>
          1,959 次阅读 -
         </em>
         <a href="http://dataunion.org/category/tech" rel="category tag">
          文章
         </a>
        </address>
       </div>
      </header>
      <div class="content-text">
       <p>
        Apriori算法和FPTree算法都是数据挖掘中的关联规则挖掘算法，处理的都是最简单的单层单维布尔关联规则。
       </p>
       <h2>
        <strong>
         Apriori算法
        </strong>
       </h2>
       <p>
        Apriori算法是一种最有影响的挖掘布尔关联规则频繁项集的算法。是基于这样的事实：算法使用频繁项集性质的先验知识。Apriori使用一种称作逐层搜索的迭代方法，
        <em>
         k-
        </em>
        项集用于探索(
        <em>
         k
        </em>
        +1)-项集。首先，找出频繁1-项集的集合。该集合记作
        <em>
         L
        </em>
        <sub>
         1
        </sub>
        。
        <em>
         L
         <sub>
          1
         </sub>
        </em>
        用于找频繁2-项集的集合
        <em>
         L
         <sub>
          2
         </sub>
        </em>
        ，而
        <em>
         L
         <sub>
          2
         </sub>
        </em>
        用于找
        <em>
         L
         <sub>
          3
         </sub>
        </em>
        ，如此下去，直到不能找到频繁
        <em>
         k
        </em>
        -项集。找每个
        <em>
         L
         <sub>
          k
         </sub>
        </em>
        需要一次数据库扫描。
       </p>
       <p>
        这个算法的思路，简单的说就是如果集合I不是频繁项集，那么所有包含集合I的更大的集合也不可能是频繁项集。
       </p>
       <p>
        算法原始数据如下：
       </p>
       <table>
        <tbody>
         <tr>
          <td width="55">
           TID
          </td>
          <td width="139">
           List of item_ID’s
          </td>
         </tr>
         <tr>
          <td width="55">
           T100
           <p>
           </p>
           <p>
            T200
           </p>
           <p>
            T300
           </p>
           <p>
            T400
           </p>
           <p>
            T500
           </p>
           <p>
            T600
           </p>
           <p>
            T700
           </p>
           <p>
            T800
           </p>
           <p>
            T900
           </p>
          </td>
          <td width="139">
           I1,I2,I5
           <p>
           </p>
           <p>
            I2,I4
           </p>
           <p>
            I2,I3
           </p>
           <p>
            I1,I2,I4
           </p>
           <p>
            I1,I3
           </p>
           <p>
            I2,I3
           </p>
           <p>
            I1,I3
           </p>
           <p>
            I1,I2,I3,I5
           </p>
           <p>
            I1,I2,I3
           </p>
          </td>
         </tr>
        </tbody>
       </table>
       <p>
        算法的基本过程如下图：
       </p>
       <p>
        首先扫描所有事务，得到1-项集C1，根据支持度要求滤去不满足条件项集，得到频繁1-项集。
       </p>
       <p>
        下面进行递归运算：
       </p>
       <p>
        已知频繁k-项集(频繁1-项集已知)，根据频繁k-项集中的项，连接得到所有可能的K+1_项，并进行剪枝（如果该k+1_项集的所有k项子集不都能满足支持度条件，那么该k+1_项集被剪掉），得到项集，然后滤去该项集中不满足支持度条件的项得到频繁k+1-项集。如果得到的项集为空，则算法结束。
       </p>
       <p>
        连接的方法：假设项集中的所有项都是按照相同的顺序排列的，那么如果[i]和[j]中的前k-1项都是完全相同的，而第k项不同，则[i]和[j]是可连接的。比如中的{I1,I2}和{I1,I3}就是可连接的，连接之后得到{I1,I2,I3}，但是{I1,I2}和{I2,I3}是不可连接的，否则将导致项集中出现重复项。
       </p>
       <p>
        关于剪枝再举例说明一下，如在由生成的过程中，列举得到的3_项集包括{I1,I2,I3},{I1,I3,I5},{I2,I3,I4},{I2,I3,I5},{I2,I4,I5}，但是由于{I3,I4}和{I4,I5}没有出现在中，所以{I2,I3,I4},{I2,I3,I5},{I2,I4,I5}被剪枝掉了。
       </p>
       <p>
        海量数据下，Apriori算法的时空复杂度都不容忽视。
       </p>
       <p>
        空间复杂度：如果数量达到的量级，那么中的候选项将达到的量级。
       </p>
       <p>
        时间复杂度：每计算一次就需要扫描一遍数据库。
       </p>
       <h2>
        <strong>
         FP-Tree算法
        </strong>
       </h2>
       <p>
        FPTree算法：在不生成候选项的情况下，完成Apriori算法的功能。
       </p>
       <p>
        FPTree算法的基本数据结构，包含一个一棵FP树和一个项头表，每个项通过一个结点链指向它在树中出现的位置。基本结构如下所示。需要注意的是项头表需要按照支持度递减排序，在FPTree中高支持度的节点只能是低支持度节点的祖先节点。
       </p>
       <p>
        另外还要交代一下FPTree算法中几个基本的概念：
       </p>
       <p>
        FP-Tree：就是上面的那棵树，是把事务数据表中的各个事务数据项按照支持度排序后，把每个事务中的数据项按降序依次插入到一棵以NULL为根结点的树中，同时在每个结点处记录该结点出现的支持度。
       </p>
       <p>
        条件模式基：包含FP-Tree中与后缀模式一起出现的前缀路径的集合。也就是同一个频繁项在PF树中的所有节点的祖先路径的集合。比如I3在FP树中一共出现了3次，其祖先路径分别是{I2，I1：2(频度为2)}，{I2：2}和{I1：2}。这3个祖先路径的集合就是频繁项I3的条件模式基。
       </p>
       <p>
        条件树：将条件模式基按照FP-Tree的构造原则形成的一个新的FP-Tree。比如上图中I3的条件树就是：
       </p>
       <p>
       </p>
       <p>
        1、 构造项头表：扫描数据库一遍，得到频繁项的集合F和每个频繁项的支持度。把F按支持度递降排序，记为L。
       </p>
       <p>
        2、 构造原始FPTree：把数据库中每个事物的频繁项按照L中的顺序进行重排。并按照重排之后的顺序把每个事物的每个频繁项插入以null为根的FPTree中。如果插入时频繁项节点已经存在了，则把该频繁项节点支持度加1；如果该节点不存在，则创建支持度为1的节点，并把该节点链接到项头表中。
       </p>
       <p>
        3、 调用FP-growth(Tree，null)开始进行挖掘。伪代码如下：
       </p>
       <p>
        <strong>
         procedure
        </strong>
        <strong>
         FP_growth
        </strong>
        (
        <em>
         Tree
        </em>
        ,
        <em>
         a
        </em>
        )
       </p>
       <p>
        <strong>
         if
        </strong>
        <em>
         Tree
        </em>
        含单个路径
        <em>
         P
        </em>
        <strong>
         then{
        </strong>
       </p>
       <p>
        <strong>
         for
        </strong>
        路径
        <em>
         P
        </em>
        中结点的每个组合（记作
        <em>
         b
        </em>
        ）
       </p>
       <p>
        产生模式
        <em>
         b
        </em>
        U
        <em>
         a
        </em>
        ，其支持度
        <em>
         support
        </em>
        =
        <em>
         b
        </em>
        中结点的最小支持度；
       </p>
       <p>
        <strong>
         } else {
        </strong>
       </p>
       <p>
        <strong>
         for each
        </strong>
        <em>
         a
         <sub>
          i
         </sub>
        </em>
        在
        <em>
         Tree
        </em>
        的头部(按照支持度由低到高顺序进行扫描){
       </p>
       <p>
        产生一个模式
        <em>
         b
        </em>
        =
        <em>
         a
         <sub>
          i
         </sub>
        </em>
        U
        <em>
         a
        </em>
        ，其支持度
        <em>
         support
        </em>
        =
        <em>
         a
         <sub>
          i
         </sub>
        </em>
        .
        <em>
         support
        </em>
        ；
       </p>
       <p>
        构造
        <em>
         b
        </em>
        的条件模式基，然后构造
        <em>
         b
        </em>
        的条件FP-树
        <em>
         Tree
        </em>
        b；
       </p>
       <p>
        <strong>
         if
        </strong>
        <em>
         Tree
        </em>
        b 不为空 then
       </p>
       <p>
        调用 FP_growth (
        <em>
         Tree
        </em>
        b,
        <em>
         b
        </em>
        )；
       </p>
       <p>
        <strong>
         }
        </strong>
       </p>
       <p>
        <strong>
         }
        </strong>
       </p>
       <p>
        FP-growth是整个算法的核心，再多啰嗦几句。
       </p>
       <p>
        FP-growth函数的输入：tree是指原始的FPTree或者是某个模式的条件FPTree，a是指模式的后缀（在第一次调用时a=NULL，在之后的递归调用中a是模式后缀）
       </p>
       <p>
        FP-growth函数的输出：在递归调用过程中输出所有的模式及其支持度（比如{I1,I2,I3}的支持度为2）。每一次调用FP_growth输出结果的模式中一定包含FP_growth函数输入的模式后缀。
       </p>
       <p>
        我们来模拟一下FP-growth的执行过程。
       </p>
       <p>
        1、 在FP-growth递归调用的第一层，模式前后a=NULL，得到的其实就是频繁1-项集。
       </p>
       <p>
        2、 对每一个频繁1-项，进行递归调用FP-growth()获得多元频繁项集。
       </p>
       <p>
        下面举两个例子说明FP-growth的执行过程。
       </p>
       <p>
        1、I5的条件模式基是(I2 I1:1), (I2 I1 I3:1)，I5构造得到的条件FP-树如下。然后递归调用FP-growth，模式后缀为I5。这个条件FP-树是单路径的，在FP_growth中直接列举{I2:2，I1:2，I3:1}的所有组合，之后和模式后缀I5取并集得到支持度&gt;2的所有模式：{ I2 I5:2, I1 I5:2, I2 I1 I5:2}。
       </p>
       <p>
        2、I5的情况是比较简单的，因为I5对应的条件FP-树是单路径的，我们再来看一下稍微复杂一点的情况I3。I3的条件模式基是(I2 I1:2), (I2:2), (I1:2)，生成的条件FP-树如左下图，然后递归调用FP-growth，模式前缀为I3。I3的条件FP-树仍然是一个多路径树，首先把模式后缀I3和条件FP-树中的项头表中的每一项取并集，得到一组模式{I2 I3:4, I1 I3:4}，但是这一组模式不是后缀为I3的所有模式。还需要递归调用FP-growth，模式后缀为{I1，I3}，{I1，I3}的条件模式基为{I2：2}，其生成的条件FP-树如右下图所示。这是一个单路径的条件FP-树，在FP_growth中把I2和模式后缀{I1，I3}取并得到模式{I1 I2 I3：2}。理论上还应该计算一下模式后缀为{I2，I3}的模式集，但是{I2，I3}的条件模式基为空，递归调用结束。最终模式后缀I3的支持度&gt;2的所有模式为：{ I2 I3:4, I1 I3:4, I1 I2 I3:2}
       </p>
       <p>
        根据FP-growth算法，最终得到的支持度&gt;2频繁模式如下：
       </p>
       <table>
        <tbody>
         <tr>
          <td width="43">
           item
          </td>
          <td width="160">
           条件模式基
          </td>
          <td width="133">
           条件FP-树
          </td>
          <td width="167">
           产生的频繁模式
          </td>
         </tr>
         <tr>
          <td width="43">
           I5
           <p>
           </p>
           <p>
            I4
           </p>
           <p>
            I3
           </p>
           <p>
            I1
           </p>
          </td>
          <td width="160">
           {(I2 I1:1),(I2 I1 I3:1)
           <p>
           </p>
           <p>
            {(I2 I1:1), (I2:1)}
           </p>
           <p>
            {(I2 I1:2), (I2:2), (I1:2)}
           </p>
           <p>
            {(I2:4)}
           </p>
          </td>
          <td width="133">
           &lt;I2:2, I1:2&gt;
           <p>
           </p>
           <p>
            &lt;I2:2&gt;
           </p>
           <p>
            &lt;I2:4, I1:2&gt;, &lt;I1:2&gt;
           </p>
           <p>
            &lt;I2:4&gt;
           </p>
          </td>
          <td width="167">
           I2 I5:2, I1 I5:2, I2 I1 I5:2
           <p>
           </p>
           <p>
            I2 I4:2
           </p>
           <p>
            I2 I3:4, I1 I3:4, I2 I1 I3:2
           </p>
           <p>
            I2 I1:4
           </p>
          </td>
         </tr>
        </tbody>
       </table>
       <p>
        FP-growth算法比Apriori算法快一个数量级，在空间复杂度方面也比Apriori也有数量级级别的优化。但是对于海量数据，FP-growth的时空复杂度仍然很高，可以采用的改进方法包括数据库划分，数据采样等等。
       </p>
       <div class="dp-highlighter bg_java">
        <div class="bar">
         <h2 class="tools">
          <a href="http://blog.csdn.net/kingzone_2008/article/details/17127567">
           Apriori算法实现
          </a>
         </h2>
        </div>
        <ol class="dp-j" start="1">
         <li class="alt">
          <span class="keyword">
           import
          </span>
          java.util.HashMap;
         </li>
         <li class="">
          <span class="keyword">
           import
          </span>
          java.util.HashSet;
         </li>
         <li class="alt">
          <span class="keyword">
           import
          </span>
          java.util.Iterator;
         </li>
         <li class="">
          <span class="keyword">
           import
          </span>
          java.util.Map;
         </li>
         <li class="alt">
          <span class="keyword">
           import
          </span>
          java.util.Set;
         </li>
         <li class="">
          <span class="keyword">
           import
          </span>
          java.util.TreeMap;
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * &lt;B&gt;关联规则挖掘：Apriori算法&lt;/B&gt;
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           *
          </span>
         </li>
         <li class="">
          <span class="comment">
           * &lt;P&gt;按照Apriori算法的基本思想来实现
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           *
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @author king
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @since 2013/06/27
          </span>
         </li>
         <li class="">
          <span class="comment">
           *
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           */
          </span>
         </li>
         <li class="">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           class
          </span>
          Apriori {
         </li>
         <li class="alt">
          <span class="keyword">
           private
          </span>
          Map&lt;Integer, Set&lt;String&gt;&gt; txDatabase;
          <span class="comment">
           // 事务数据库
          </span>
         </li>
         <li class="">
          <span class="keyword">
           private
          </span>
          Float minSup;
          <span class="comment">
           // 最小支持度
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           private
          </span>
          Float minConf;
          <span class="comment">
           // 最小置信度
          </span>
         </li>
         <li class="">
          <span class="keyword">
           private
          </span>
          Integer txDatabaseCount;
          <span class="comment">
           // 事务数据库中的事务数
          </span>
         </li>
         <li class="alt">
         </li>
         <li class="">
          <span class="keyword">
           private
          </span>
          Map&lt;Integer, Set&lt;Set&lt;String&gt;&gt;&gt; freqItemSet;
          <span class="comment">
           // 频繁项集集合
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           private
          </span>
          Map&lt;Set&lt;String&gt;, Set&lt;Set&lt;String&gt;&gt;&gt; assiciationRules;
          <span class="comment">
           // 频繁关联规则集合
          </span>
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="keyword">
           public
          </span>
          Apriori(
         </li>
         <li class="">
          Map&lt;Integer, Set&lt;String&gt;&gt; txDatabase,
         </li>
         <li class="alt">
          Float minSup,
         </li>
         <li class="">
          Float minConf) {
         </li>
         <li class="alt">
          <span class="keyword">
           this
          </span>
          .txDatabase = txDatabase;
         </li>
         <li class="">
          <span class="keyword">
           this
          </span>
          .minSup = minSup;
         </li>
         <li class="alt">
          <span class="keyword">
           this
          </span>
          .minConf = minConf;
         </li>
         <li class="">
          <span class="keyword">
           this
          </span>
          .txDatabaseCount =
          <span class="keyword">
           this
          </span>
          .txDatabase.size();
         </li>
         <li class="alt">
          freqItemSet =
          <span class="keyword">
           new
          </span>
          TreeMap&lt;Integer, Set&lt;Set&lt;String&gt;&gt;&gt;();
         </li>
         <li class="">
          assiciationRules =
          <span class="keyword">
           new
          </span>
          HashMap&lt;Set&lt;String&gt;, Set&lt;Set&lt;String&gt;&gt;&gt;();
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 扫描事务数据库，计算频繁1-项集
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @return
          </span>
         </li>
         <li class="">
          <span class="comment">
           */
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           public
          </span>
          Map&lt;Set&lt;String&gt;, Float&gt; getFreq1ItemSet() {
         </li>
         <li class="">
          Map&lt;Set&lt;String&gt;, Float&gt; freq1ItemSetMap =
          <span class="keyword">
           new
          </span>
          HashMap&lt;Set&lt;String&gt;, Float&gt;();
         </li>
         <li class="alt">
          Map&lt;Set&lt;String&gt;, Integer&gt; candFreq1ItemSet =
          <span class="keyword">
           this
          </span>
          .getCandFreq1ItemSet();
         </li>
         <li class="">
          Iterator&lt;Map.Entry&lt;Set&lt;String&gt;, Integer&gt;&gt; it = candFreq1ItemSet.entrySet().iterator();
         </li>
         <li class="alt">
          <span class="keyword">
           while
          </span>
          (it.hasNext()) {
         </li>
         <li class="">
          Map.Entry&lt;Set&lt;String&gt;, Integer&gt; entry = it.next();
         </li>
         <li class="alt">
          <span class="comment">
           // 计算支持度
          </span>
         </li>
         <li class="">
          Float supported =
          <span class="keyword">
           new
          </span>
          Float(entry.getValue().toString())/
          <span class="keyword">
           new
          </span>
          Float(txDatabaseCount);
         </li>
         <li class="alt">
          <span class="keyword">
           if
          </span>
          (supported&gt;=minSup) {
         </li>
         <li class="">
          freq1ItemSetMap.put(entry.getKey(), supported);
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          <span class="keyword">
           return
          </span>
          freq1ItemSetMap;
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
         </li>
         <li class="">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * 计算候选频繁1-项集
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @return
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           */
          </span>
         </li>
         <li class="">
          <span class="keyword">
           public
          </span>
          Map&lt;Set&lt;String&gt;, Integer&gt; getCandFreq1ItemSet() {
         </li>
         <li class="alt">
          Map&lt;Set&lt;String&gt;, Integer&gt; candFreq1ItemSetMap =
          <span class="keyword">
           new
          </span>
          HashMap&lt;Set&lt;String&gt;, Integer&gt;();
         </li>
         <li class="">
          Iterator&lt;Map.Entry&lt;Integer, Set&lt;String&gt;&gt;&gt; it = txDatabase.entrySet().iterator();
         </li>
         <li class="alt">
          <span class="comment">
           // 统计支持数，生成候选频繁1-项集
          </span>
         </li>
         <li class="">
          <span class="keyword">
           while
          </span>
          (it.hasNext()) {
         </li>
         <li class="alt">
          Map.Entry&lt;Integer, Set&lt;String&gt;&gt; entry = it.next();
         </li>
         <li class="">
          Set&lt;String&gt; itemSet = entry.getValue();
         </li>
         <li class="alt">
          <span class="keyword">
           for
          </span>
          (String item : itemSet) {
         </li>
         <li class="">
          Set&lt;String&gt; key =
          <span class="keyword">
           new
          </span>
          HashSet&lt;String&gt;();
         </li>
         <li class="alt">
          key.add(item.trim());
         </li>
         <li class="">
          <span class="keyword">
           if
          </span>
          (!candFreq1ItemSetMap.containsKey(key)) {
         </li>
         <li class="alt">
          Integer value =
          <span class="number">
           1
          </span>
          ;
         </li>
         <li class="">
          candFreq1ItemSetMap.put(key, value);
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          <span class="keyword">
           else
          </span>
          {
         </li>
         <li class="alt">
          Integer value =
          <span class="number">
           1
          </span>
          +candFreq1ItemSetMap.get(key);
         </li>
         <li class="">
          candFreq1ItemSetMap.put(key, value);
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          <span class="keyword">
           return
          </span>
          candFreq1ItemSetMap;
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 根据频繁(k-1)-项集计算候选频繁k-项集
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           *
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @param m 其中m=k-1
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @param freqMItemSet 频繁(k-1)-项集
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @return
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           */
          </span>
         </li>
         <li class="">
          <span class="keyword">
           public
          </span>
          Set&lt;Set&lt;String&gt;&gt; aprioriGen(
          <span class="keyword">
           int
          </span>
          m, Set&lt;Set&lt;String&gt;&gt; freqMItemSet) {
         </li>
         <li class="alt">
          Set&lt;Set&lt;String&gt;&gt; candFreqKItemSet =
          <span class="keyword">
           new
          </span>
          HashSet&lt;Set&lt;String&gt;&gt;();
         </li>
         <li class="">
          Iterator&lt;Set&lt;String&gt;&gt; it = freqMItemSet.iterator();
         </li>
         <li class="alt">
          Set&lt;String&gt; originalItemSet =
          <span class="keyword">
           null
          </span>
          ;
         </li>
         <li class="">
          <span class="keyword">
           while
          </span>
          (it.hasNext()) {
         </li>
         <li class="alt">
          originalItemSet = it.next();
         </li>
         <li class="">
          Iterator&lt;Set&lt;String&gt;&gt; itr =
          <span class="keyword">
           this
          </span>
          .getIterator(originalItemSet, freqMItemSet);
         </li>
         <li class="alt">
          <span class="keyword">
           while
          </span>
          (itr.hasNext()) {
         </li>
         <li class="">
          Set&lt;String&gt; identicalSet =
          <span class="keyword">
           new
          </span>
          HashSet&lt;String&gt;();
          <span class="comment">
           // 两个项集相同元素的集合(集合的交运算)
          </span>
         </li>
         <li class="alt">
          identicalSet.addAll(originalItemSet);
         </li>
         <li class="">
          Set&lt;String&gt; set = itr.next();
         </li>
         <li class="alt">
          identicalSet.retainAll(set);
          <span class="comment">
           // identicalSet中剩下的元素是identicalSet与set集合中公有的元素
          </span>
         </li>
         <li class="">
          <span class="keyword">
           if
          </span>
          (identicalSet.size() == m-
          <span class="number">
           1
          </span>
          ) {
          <span class="comment">
           // (k-1)-项集中k-2个相同
          </span>
         </li>
         <li class="alt">
          Set&lt;String&gt; differentSet =
          <span class="keyword">
           new
          </span>
          HashSet&lt;String&gt;();
          <span class="comment">
           // 两个项集不同元素的集合(集合的差运算)
          </span>
         </li>
         <li class="">
          differentSet.addAll(originalItemSet);
         </li>
         <li class="alt">
          differentSet.removeAll(set);
          <span class="comment">
           // 因为有k-2个相同，则differentSet中一定剩下一个元素，即differentSet大小为1
          </span>
         </li>
         <li class="">
          differentSet.addAll(set);
          <span class="comment">
           // 构造候选k-项集的一个元素(set大小为k-1,differentSet大小为k)
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           if
          </span>
          (!
          <span class="keyword">
           this
          </span>
          .has_infrequent_subset(differentSet, freqMItemSet))
         </li>
         <li class="">
          candFreqKItemSet.add(differentSet);
          <span class="comment">
           // 加入候选k-项集集合
          </span>
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          <span class="keyword">
           return
          </span>
          candFreqKItemSet;
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 使用先验知识，剪枝。若候选k项集中存在k-1项子集不是频繁k-1项集，则删除该候选k项集
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @param candKItemSet
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @param freqMItemSet
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @return
          </span>
         </li>
         <li class="">
          <span class="comment">
           */
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           private
          </span>
          <span class="keyword">
           boolean
          </span>
          has_infrequent_subset(Set&lt;String&gt; candKItemSet, Set&lt;Set&lt;String&gt;&gt; freqMItemSet) {
         </li>
         <li class="">
          Set&lt;String&gt; tempSet =
          <span class="keyword">
           new
          </span>
          HashSet&lt;String&gt;();
         </li>
         <li class="alt">
          tempSet.addAll(candKItemSet);
         </li>
         <li class="">
          Iterator&lt;String&gt; itItem = candKItemSet.iterator();
         </li>
         <li class="alt">
          <span class="keyword">
           while
          </span>
          (itItem.hasNext()) {
         </li>
         <li class="">
          String item = itItem.next();
         </li>
         <li class="alt">
          tempSet.remove(item);
          <span class="comment">
           // 该候选去掉一项后变为k-1项集
          </span>
         </li>
         <li class="">
          <span class="keyword">
           if
          </span>
          (!freqMItemSet.contains(tempSet))
          <span class="comment">
           // 判断k-1项集是否是频繁项集
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           return
          </span>
          <span class="keyword">
           true
          </span>
          ;
         </li>
         <li class="">
          tempSet.add(item);
          <span class="comment">
           // 恢复
          </span>
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          <span class="keyword">
           return
          </span>
          <span class="keyword">
           false
          </span>
          ;
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 根据一个频繁k-项集的元素(集合)，获取到频繁k-项集的从该元素开始的迭代器实例
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @param itemSet
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @param freqKItemSet 频繁k-项集
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @return
          </span>
         </li>
         <li class="">
          <span class="comment">
           */
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           private
          </span>
          Iterator&lt;Set&lt;String&gt;&gt; getIterator(Set&lt;String&gt; itemSet, Set&lt;Set&lt;String&gt;&gt; freqKItemSet) {
         </li>
         <li class="">
          Iterator&lt;Set&lt;String&gt;&gt; it = freqKItemSet.iterator();
         </li>
         <li class="alt">
          <span class="keyword">
           while
          </span>
          (it.hasNext()) {
         </li>
         <li class="">
          <span class="keyword">
           if
          </span>
          (itemSet.equals(it.next())) {
         </li>
         <li class="alt">
          <span class="keyword">
           break
          </span>
          ;
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          <span class="keyword">
           return
          </span>
          it;
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 根据频繁(k-1)-项集，调用aprioriGen方法，计算频繁k-项集
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           *
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @param k
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @param freqMItemSet 频繁(k-1)-项集
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @return
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           */
          </span>
         </li>
         <li class="">
          <span class="keyword">
           public
          </span>
          Map&lt;Set&lt;String&gt;, Float&gt; getFreqKItemSet(
          <span class="keyword">
           int
          </span>
          k, Set&lt;Set&lt;String&gt;&gt; freqMItemSet) {
         </li>
         <li class="alt">
          Map&lt;Set&lt;String&gt;, Integer&gt; candFreqKItemSetMap =
          <span class="keyword">
           new
          </span>
          HashMap&lt;Set&lt;String&gt;, Integer&gt;();
         </li>
         <li class="">
          <span class="comment">
           // 调用aprioriGen方法，得到候选频繁k-项集
          </span>
         </li>
         <li class="alt">
          Set&lt;Set&lt;String&gt;&gt; candFreqKItemSet =
          <span class="keyword">
           this
          </span>
          .aprioriGen(k-
          <span class="number">
           1
          </span>
          , freqMItemSet);
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           // 扫描事务数据库
          </span>
         </li>
         <li class="">
          Iterator&lt;Map.Entry&lt;Integer, Set&lt;String&gt;&gt;&gt; it = txDatabase.entrySet().iterator();
         </li>
         <li class="alt">
          <span class="comment">
           // 统计支持数
          </span>
         </li>
         <li class="">
          <span class="keyword">
           while
          </span>
          (it.hasNext()) {
         </li>
         <li class="alt">
          Map.Entry&lt;Integer, Set&lt;String&gt;&gt; entry = it.next();
         </li>
         <li class="">
          Iterator&lt;Set&lt;String&gt;&gt; kit = candFreqKItemSet.iterator();
         </li>
         <li class="alt">
          <span class="keyword">
           while
          </span>
          (kit.hasNext()) {
         </li>
         <li class="">
          Set&lt;String&gt; kSet = kit.next();
         </li>
         <li class="alt">
          Set&lt;String&gt; set =
          <span class="keyword">
           new
          </span>
          HashSet&lt;String&gt;();
         </li>
         <li class="">
          set.addAll(kSet);
         </li>
         <li class="alt">
          set.removeAll(entry.getValue());
          <span class="comment">
           // 候选频繁k-项集与事务数据库中元素做差运算
          </span>
         </li>
         <li class="">
          <span class="keyword">
           if
          </span>
          (set.isEmpty()) {
          <span class="comment">
           // 如果拷贝set为空，支持数加1
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           if
          </span>
          (candFreqKItemSetMap.get(kSet) ==
          <span class="keyword">
           null
          </span>
          ) {
         </li>
         <li class="">
          Integer value =
          <span class="number">
           1
          </span>
          ;
         </li>
         <li class="alt">
          candFreqKItemSetMap.put(kSet, value);
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          <span class="keyword">
           else
          </span>
          {
         </li>
         <li class="">
          Integer value =
          <span class="number">
           1
          </span>
          +candFreqKItemSetMap.get(kSet);
         </li>
         <li class="alt">
          candFreqKItemSetMap.put(kSet, value);
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          <span class="comment">
           // 计算支持度，生成频繁k-项集，并返回
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           return
          </span>
          support(candFreqKItemSetMap);
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
         </li>
         <li class="">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * 根据候选频繁k-项集，得到频繁k-项集
          </span>
         </li>
         <li class="">
          <span class="comment">
           *
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @param candFreqKItemSetMap 候选k项集(包含支持计数)
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @return freqKItemSetMap 频繁k项集及其支持度(比例)
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           */
          </span>
         </li>
         <li class="">
          <span class="keyword">
           public
          </span>
          Map&lt;Set&lt;String&gt;, Float&gt; support(Map&lt;Set&lt;String&gt;, Integer&gt; candFreqKItemSetMap) {
         </li>
         <li class="alt">
          Map&lt;Set&lt;String&gt;, Float&gt; freqKItemSetMap =
          <span class="keyword">
           new
          </span>
          HashMap&lt;Set&lt;String&gt;, Float&gt;();
         </li>
         <li class="">
          Iterator&lt;Map.Entry&lt;Set&lt;String&gt;, Integer&gt;&gt; it = candFreqKItemSetMap.entrySet().iterator();
         </li>
         <li class="alt">
          <span class="keyword">
           while
          </span>
          (it.hasNext()) {
         </li>
         <li class="">
          Map.Entry&lt;Set&lt;String&gt;, Integer&gt; entry = it.next();
         </li>
         <li class="alt">
          <span class="comment">
           // 计算支持度
          </span>
         </li>
         <li class="">
          Float supportRate =
          <span class="keyword">
           new
          </span>
          Float(entry.getValue().toString())/
          <span class="keyword">
           new
          </span>
          Float(txDatabaseCount);
         </li>
         <li class="alt">
          <span class="keyword">
           if
          </span>
          (supportRate&lt;minSup) {
          <span class="comment">
           // 如果不满足最小支持度，删除
          </span>
         </li>
         <li class="">
          it.remove();
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          <span class="keyword">
           else
          </span>
          {
         </li>
         <li class="alt">
          freqKItemSetMap.put(entry.getKey(), supportRate);
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          <span class="keyword">
           return
          </span>
          freqKItemSetMap;
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 挖掘全部频繁项集
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           */
          </span>
         </li>
         <li class="">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           void
          </span>
          mineFreqItemSet() {
         </li>
         <li class="alt">
          <span class="comment">
           // 计算频繁1-项集
          </span>
         </li>
         <li class="">
          Set&lt;Set&lt;String&gt;&gt; freqKItemSet =
          <span class="keyword">
           this
          </span>
          .getFreq1ItemSet().keySet();
         </li>
         <li class="alt">
          freqItemSet.put(
          <span class="number">
           1
          </span>
          , freqKItemSet);
         </li>
         <li class="">
          <span class="comment">
           // 计算频繁k-项集(k&gt;1)
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           int
          </span>
          k =
          <span class="number">
           2
          </span>
          ;
         </li>
         <li class="">
          <span class="keyword">
           while
          </span>
          (
          <span class="keyword">
           true
          </span>
          ) {
         </li>
         <li class="alt">
          Map&lt;Set&lt;String&gt;, Float&gt; freqKItemSetMap =
          <span class="keyword">
           this
          </span>
          .getFreqKItemSet(k, freqKItemSet);
         </li>
         <li class="">
          <span class="keyword">
           if
          </span>
          (!freqKItemSetMap.isEmpty()) {
         </li>
         <li class="alt">
          <span class="keyword">
           this
          </span>
          .freqItemSet.put(k, freqKItemSetMap.keySet());
         </li>
         <li class="">
          freqKItemSet = freqKItemSetMap.keySet();
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          <span class="keyword">
           else
          </span>
          {
         </li>
         <li class="alt">
          <span class="keyword">
           break
          </span>
          ;
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          k++;
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * &lt;P&gt;挖掘频繁关联规则
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * &lt;P&gt;首先挖掘出全部的频繁项集，在此基础上挖掘频繁关联规则
          </span>
         </li>
         <li class="">
          <span class="comment">
           */
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           void
          </span>
          mineAssociationRules() {
         </li>
         <li class="">
          freqItemSet.remove(
          <span class="number">
           1
          </span>
          );
          <span class="comment">
           // 删除频繁1-项集
          </span>
         </li>
         <li class="alt">
          Iterator&lt;Map.Entry&lt;Integer, Set&lt;Set&lt;String&gt;&gt;&gt;&gt; it = freqItemSet.entrySet().iterator();
         </li>
         <li class="">
          <span class="keyword">
           while
          </span>
          (it.hasNext()) {
         </li>
         <li class="alt">
          Map.Entry&lt;Integer, Set&lt;Set&lt;String&gt;&gt;&gt; entry = it.next();
         </li>
         <li class="">
          <span class="keyword">
           for
          </span>
          (Set&lt;String&gt; itemSet : entry.getValue()) {
         </li>
         <li class="alt">
          <span class="comment">
           // 对每个频繁项集进行关联规则的挖掘
          </span>
         </li>
         <li class="">
          mine(itemSet);
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 对从频繁项集集合freqItemSet中每迭代出一个频繁项集元素，执行一次关联规则的挖掘
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @param itemSet 频繁项集集合freqItemSet中的一个频繁项集元素
          </span>
         </li>
         <li class="">
          <span class="comment">
           */
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           void
          </span>
          mine(Set&lt;String&gt; itemSet) {
         </li>
         <li class="">
          <span class="keyword">
           int
          </span>
          n = itemSet.size()/
          <span class="number">
           2
          </span>
          ;
          <span class="comment">
           // 根据集合的对称性，只需要得到一半的真子集
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           for
          </span>
          (
          <span class="keyword">
           int
          </span>
          i=
          <span class="number">
           1
          </span>
          ; i&lt;=n; i++) {
         </li>
         <li class="">
          <span class="comment">
           // 得到频繁项集元素itemSet的作为条件的真子集集合
          </span>
         </li>
         <li class="alt">
          Set&lt;Set&lt;String&gt;&gt; properSubset = ProperSubsetCombination.getProperSubset(i, itemSet);
         </li>
         <li class="">
          <span class="comment">
           // 对条件的真子集集合中的每个条件项集，获取到对应的结论项集，从而进一步挖掘频繁关联规则
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           for
          </span>
          (Set&lt;String&gt; conditionSet : properSubset) {
         </li>
         <li class="">
          Set&lt;String&gt; conclusionSet =
          <span class="keyword">
           new
          </span>
          HashSet&lt;String&gt;();
         </li>
         <li class="alt">
          conclusionSet.addAll(itemSet);
         </li>
         <li class="">
          conclusionSet.removeAll(conditionSet);
          <span class="comment">
           // 删除条件中存在的频繁项
          </span>
         </li>
         <li class="alt">
          confide(conditionSet, conclusionSet);
          <span class="comment">
           // 调用计算置信度的方法，并且挖掘出频繁关联规则
          </span>
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
         </li>
         <li class="">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * 对得到的一个条件项集和对应的结论项集，计算该关联规则的支持计数，从而根据置信度判断是否是频繁关联规则
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @param conditionSet 条件频繁项集
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @param conclusionSet 结论频繁项集
          </span>
         </li>
         <li class="">
          <span class="comment">
           */
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           void
          </span>
          confide(Set&lt;String&gt; conditionSet, Set&lt;String&gt; conclusionSet) {
         </li>
         <li class="">
          <span class="comment">
           // 扫描事务数据库
          </span>
         </li>
         <li class="alt">
          Iterator&lt;Map.Entry&lt;Integer, Set&lt;String&gt;&gt;&gt; it = txDatabase.entrySet().iterator();
         </li>
         <li class="">
          <span class="comment">
           // 统计关联规则支持计数
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           int
          </span>
          conditionToConclusionCnt =
          <span class="number">
           0
          </span>
          ;
          <span class="comment">
           // 关联规则(条件项集推出结论项集)计数
          </span>
         </li>
         <li class="">
          <span class="keyword">
           int
          </span>
          conclusionToConditionCnt =
          <span class="number">
           0
          </span>
          ;
          <span class="comment">
           // 关联规则(结论项集推出条件项集)计数
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           int
          </span>
          supCnt =
          <span class="number">
           0
          </span>
          ;
          <span class="comment">
           // 关联规则支持计数
          </span>
         </li>
         <li class="">
          <span class="keyword">
           while
          </span>
          (it.hasNext()) {
         </li>
         <li class="alt">
          Map.Entry&lt;Integer, Set&lt;String&gt;&gt; entry = it.next();
         </li>
         <li class="">
          Set&lt;String&gt; txSet = entry.getValue();
         </li>
         <li class="alt">
          Set&lt;String&gt; set1 =
          <span class="keyword">
           new
          </span>
          HashSet&lt;String&gt;();
         </li>
         <li class="">
          Set&lt;String&gt; set2 =
          <span class="keyword">
           new
          </span>
          HashSet&lt;String&gt;();
         </li>
         <li class="alt">
          set1.addAll(conditionSet);
         </li>
         <li class="">
         </li>
         <li class="alt">
          set1.removeAll(txSet);
          <span class="comment">
           // 集合差运算：set-txSet
          </span>
         </li>
         <li class="">
          <span class="keyword">
           if
          </span>
          (set1.isEmpty()) {
          <span class="comment">
           // 如果set为空，说明事务数据库中包含条件频繁项conditionSet
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           // 计数
          </span>
         </li>
         <li class="">
          conditionToConclusionCnt++;
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          set2.addAll(conclusionSet);
         </li>
         <li class="alt">
          set2.removeAll(txSet);
          <span class="comment">
           // 集合差运算：set-txSet
          </span>
         </li>
         <li class="">
          <span class="keyword">
           if
          </span>
          (set2.isEmpty()) {
          <span class="comment">
           // 如果set为空，说明事务数据库中包含结论频繁项conclusionSet
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           // 计数
          </span>
         </li>
         <li class="">
          conclusionToConditionCnt++;
         </li>
         <li class="alt">
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          <span class="keyword">
           if
          </span>
          (set1.isEmpty() &amp;&amp; set2.isEmpty()) {
         </li>
         <li class="">
          supCnt++;
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          <span class="comment">
           // 计算置信度
          </span>
         </li>
         <li class="">
          Float conditionToConclusionConf =
          <span class="keyword">
           new
          </span>
          Float(supCnt)/
          <span class="keyword">
           new
          </span>
          Float(conditionToConclusionCnt);
         </li>
         <li class="alt">
          <span class="keyword">
           if
          </span>
          (conditionToConclusionConf&gt;=minConf) {
         </li>
         <li class="">
          <span class="keyword">
           if
          </span>
          (assiciationRules.get(conditionSet) ==
          <span class="keyword">
           null
          </span>
          ) {
          <span class="comment">
           // 如果不存在以该条件频繁项集为条件的关联规则
          </span>
         </li>
         <li class="alt">
          Set&lt;Set&lt;String&gt;&gt; conclusionSetSet =
          <span class="keyword">
           new
          </span>
          HashSet&lt;Set&lt;String&gt;&gt;();
         </li>
         <li class="">
          conclusionSetSet.add(conclusionSet);
         </li>
         <li class="alt">
          assiciationRules.put(conditionSet, conclusionSetSet);
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          <span class="keyword">
           else
          </span>
          {
         </li>
         <li class="">
          assiciationRules.get(conditionSet).add(conclusionSet);
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          Float conclusionToConditionConf =
          <span class="keyword">
           new
          </span>
          Float(supCnt)/
          <span class="keyword">
           new
          </span>
          Float(conclusionToConditionCnt);
         </li>
         <li class="">
          <span class="keyword">
           if
          </span>
          (conclusionToConditionConf&gt;=minConf) {
         </li>
         <li class="alt">
          <span class="keyword">
           if
          </span>
          (assiciationRules.get(conclusionSet) ==
          <span class="keyword">
           null
          </span>
          ) {
          <span class="comment">
           // 如果不存在以该结论频繁项集为条件的关联规则
          </span>
         </li>
         <li class="">
          Set&lt;Set&lt;String&gt;&gt; conclusionSetSet =
          <span class="keyword">
           new
          </span>
          HashSet&lt;Set&lt;String&gt;&gt;();
         </li>
         <li class="alt">
          conclusionSetSet.add(conditionSet);
         </li>
         <li class="">
          assiciationRules.put(conclusionSet, conclusionSetSet);
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          <span class="keyword">
           else
          </span>
          {
         </li>
         <li class="alt">
          assiciationRules.get(conclusionSet).add(conditionSet);
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 经过挖掘得到的频繁项集Map
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           *
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @return 挖掘得到的频繁项集集合
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           */
          </span>
         </li>
         <li class="">
          <span class="keyword">
           public
          </span>
          Map&lt;Integer, Set&lt;Set&lt;String&gt;&gt;&gt; getFreqItemSet() {
         </li>
         <li class="alt">
          <span class="keyword">
           return
          </span>
          freqItemSet;
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 获取挖掘到的全部的频繁关联规则的集合
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @return 频繁关联规则集合
          </span>
         </li>
         <li class="">
          <span class="comment">
           */
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           public
          </span>
          Map&lt;Set&lt;String&gt;, Set&lt;Set&lt;String&gt;&gt;&gt; getAssiciationRules() {
         </li>
         <li class="">
          <span class="keyword">
           return
          </span>
          assiciationRules;
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          }
         </li>
        </ol>
       </div>
       <p>
        测试类如下：
       </p>
       <div class="dp-highlighter bg_java">
        <div class="bar">
         <div class="tools">
         </div>
        </div>
        <ol class="dp-j" start="1">
         <li class="alt">
          <span class="keyword">
           import
          </span>
          java.io.BufferedReader;
         </li>
         <li class="">
          <span class="keyword">
           import
          </span>
          java.io.File;
         </li>
         <li class="alt">
          <span class="keyword">
           import
          </span>
          java.io.FileNotFoundException;
         </li>
         <li class="">
          <span class="keyword">
           import
          </span>
          java.io.FileReader;
         </li>
         <li class="alt">
          <span class="keyword">
           import
          </span>
          java.io.IOException;
         </li>
         <li class="">
          <span class="keyword">
           import
          </span>
          java.util.HashMap;
         </li>
         <li class="alt">
          <span class="keyword">
           import
          </span>
          java.util.HashSet;
         </li>
         <li class="">
          <span class="keyword">
           import
          </span>
          java.util.Map;
         </li>
         <li class="alt">
          <span class="keyword">
           import
          </span>
          java.util.Set;
         </li>
         <li class="">
          <span class="keyword">
           import
          </span>
          java.util.TreeSet;
         </li>
         <li class="alt">
         </li>
         <li class="">
          <span class="keyword">
           import
          </span>
          junit.framework.TestCase;
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * &lt;B&gt;Apriori算法测试类&lt;/B&gt;
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           *
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @author king
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @date 2013/07/28
          </span>
         </li>
         <li class="">
          <span class="comment">
           */
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           class
          </span>
          AprioriTest
          <span class="keyword">
           extends
          </span>
          TestCase {
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="keyword">
           private
          </span>
          Apriori apriori;
         </li>
         <li class="">
          <span class="keyword">
           private
          </span>
          Map&lt;Integer, Set&lt;String&gt;&gt; txDatabase;
         </li>
         <li class="alt">
          <span class="keyword">
           private
          </span>
          Float minSup =
          <span class="keyword">
           new
          </span>
          Float(
          <span class="string">
           “0.50”
          </span>
          );
         </li>
         <li class="">
          <span class="keyword">
           private
          </span>
          Float minConf =
          <span class="keyword">
           new
          </span>
          Float(
          <span class="string">
           “0.70”
          </span>
          );
         </li>
         <li class="alt">
         </li>
         <li class="">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           static
          </span>
          <span class="keyword">
           void
          </span>
          main(String []args)
          <span class="keyword">
           throws
          </span>
          Exception {
         </li>
         <li class="alt">
          AprioriTest at =
          <span class="keyword">
           new
          </span>
          AprioriTest();
         </li>
         <li class="">
          at.setUp();
         </li>
         <li class="alt">
         </li>
         <li class="">
          <span class="keyword">
           long
          </span>
          from = System.currentTimeMillis();
         </li>
         <li class="alt">
          at.testGetFreqItemSet();
         </li>
         <li class="">
          <span class="keyword">
           long
          </span>
          to = System.currentTimeMillis();
         </li>
         <li class="alt">
          System.out.println(
          <span class="string">
           “耗时：”
          </span>
          + (to-from));
         </li>
         <li class="">
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="annotation">
           @Override
          </span>
         </li>
         <li class="">
          <span class="keyword">
           protected
          </span>
          <span class="keyword">
           void
          </span>
          setUp()
          <span class="keyword">
           throws
          </span>
          Exception {
         </li>
         <li class="alt">
          <span class="comment">
           //      create(); // 构造事务数据库
          </span>
         </li>
         <li class="">
          <span class="keyword">
           this
          </span>
          .buildData(Integer.MAX_VALUE,
          <span class="string">
           “f_faqk_.dat”
          </span>
          );
         </li>
         <li class="alt">
          apriori =
          <span class="keyword">
           new
          </span>
          Apriori(txDatabase, minSup, minConf);
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
         </li>
         <li class="">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * 构造模拟事务数据库txDatabase
          </span>
         </li>
         <li class="">
          <span class="comment">
           */
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           void
          </span>
          create() {
         </li>
         <li class="">
          txDatabase =
          <span class="keyword">
           new
          </span>
          HashMap&lt;Integer, Set&lt;String&gt;&gt;();
         </li>
         <li class="alt">
          Set&lt;String&gt; set1 =
          <span class="keyword">
           new
          </span>
          TreeSet&lt;String&gt;();
         </li>
         <li class="">
          set1.add(
          <span class="string">
           “A”
          </span>
          );
         </li>
         <li class="alt">
          set1.add(
          <span class="string">
           “B”
          </span>
          );
         </li>
         <li class="">
          set1.add(
          <span class="string">
           “C”
          </span>
          );
         </li>
         <li class="alt">
          set1.add(
          <span class="string">
           “E”
          </span>
          );
         </li>
         <li class="">
          txDatabase.put(
          <span class="number">
           1
          </span>
          , set1);
         </li>
         <li class="alt">
          Set&lt;String&gt; set2 =
          <span class="keyword">
           new
          </span>
          TreeSet&lt;String&gt;();
         </li>
         <li class="">
          set2.add(
          <span class="string">
           “A”
          </span>
          );
         </li>
         <li class="alt">
          set2.add(
          <span class="string">
           “B”
          </span>
          );
         </li>
         <li class="">
          set2.add(
          <span class="string">
           “C”
          </span>
          );
         </li>
         <li class="alt">
          txDatabase.put(
          <span class="number">
           2
          </span>
          , set2);
         </li>
         <li class="">
          Set&lt;String&gt; set3 =
          <span class="keyword">
           new
          </span>
          TreeSet&lt;String&gt;();
         </li>
         <li class="alt">
          set3.add(
          <span class="string">
           “C”
          </span>
          );
         </li>
         <li class="">
          set3.add(
          <span class="string">
           “D”
          </span>
          );
         </li>
         <li class="alt">
          txDatabase.put(
          <span class="number">
           3
          </span>
          , set3);
         </li>
         <li class="">
          Set&lt;String&gt; set4 =
          <span class="keyword">
           new
          </span>
          TreeSet&lt;String&gt;();
         </li>
         <li class="alt">
          set4.add(
          <span class="string">
           “A”
          </span>
          );
         </li>
         <li class="">
          set4.add(
          <span class="string">
           “B”
          </span>
          );
         </li>
         <li class="alt">
          set4.add(
          <span class="string">
           “E”
          </span>
          );
         </li>
         <li class="">
          txDatabase.put(
          <span class="number">
           4
          </span>
          , set4);
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 构造数据集
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * @param fileName 存储事务数据的文件名
          </span>
         </li>
         <li class="">
          <span class="comment">
           * @param totalcount 获取的事务数
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           */
          </span>
         </li>
         <li class="">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           void
          </span>
          buildData(
          <span class="keyword">
           int
          </span>
          totalCount, String…fileName) {
         </li>
         <li class="alt">
          txDatabase =
          <span class="keyword">
           new
          </span>
          HashMap&lt;Integer, Set&lt;String&gt;&gt;();
         </li>
         <li class="">
          <span class="keyword">
           if
          </span>
          (fileName.length !=
          <span class="number">
           0
          </span>
          ){
         </li>
         <li class="alt">
          File file =
          <span class="keyword">
           new
          </span>
          File(fileName[
          <span class="number">
           0
          </span>
          ]);
         </li>
         <li class="">
          <span class="keyword">
           int
          </span>
          count =
          <span class="number">
           0
          </span>
          ;
         </li>
         <li class="alt">
          <span class="keyword">
           try
          </span>
          {
         </li>
         <li class="">
          BufferedReader reader =
          <span class="keyword">
           new
          </span>
          BufferedReader(
          <span class="keyword">
           new
          </span>
          FileReader(file));
         </li>
         <li class="alt">
          String line;
         </li>
         <li class="">
          <span class="keyword">
           while
          </span>
          ( (line = reader.readLine()) !=
          <span class="keyword">
           null
          </span>
          ){
         </li>
         <li class="alt">
          String []arr = line.split(
          <span class="string">
           ” “
          </span>
          );
         </li>
         <li class="">
          Set&lt;String&gt; set =
          <span class="keyword">
           new
          </span>
          HashSet&lt;String&gt;();
         </li>
         <li class="alt">
          <span class="keyword">
           for
          </span>
          (String s : arr)
         </li>
         <li class="">
          set.add(s);
         </li>
         <li class="alt">
          count++;
         </li>
         <li class="">
          <span class="keyword">
           this
          </span>
          .txDatabase.put(count, set);
         </li>
         <li class="alt">
         </li>
         <li class="">
          <span class="keyword">
           if
          </span>
          (count &gt;= totalCount)
          <span class="keyword">
           return
          </span>
          ;
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
          }
          <span class="keyword">
           catch
          </span>
          (FileNotFoundException e) {
         </li>
         <li class="alt">
          e.printStackTrace();
         </li>
         <li class="">
          }
          <span class="keyword">
           catch
          </span>
          (IOException e) {
         </li>
         <li class="alt">
          e.printStackTrace();
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
          <span class="keyword">
           else
          </span>
          {
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 测试挖掘频繁1-项集
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           */
          </span>
         </li>
         <li class="">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           void
          </span>
          testFreq1ItemSet() {
         </li>
         <li class="alt">
          System.out.println(
          <span class="string">
           “挖掘频繁1-项集 : “
          </span>
          + apriori.getFreq1ItemSet());
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
         </li>
         <li class="">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * 测试aprioriGen方法，生成候选频繁项集
          </span>
         </li>
         <li class="">
          <span class="comment">
           */
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           void
          </span>
          testAprioriGen() {
         </li>
         <li class="">
          System.out.println(
         </li>
         <li class="alt">
          <span class="string">
           “候选频繁2-项集 ： “
          </span>
          +
         </li>
         <li class="">
          <span class="keyword">
           this
          </span>
          .apriori.aprioriGen(
          <span class="number">
           1
          </span>
          ,
          <span class="keyword">
           this
          </span>
          .apriori.getFreq1ItemSet().keySet())
         </li>
         <li class="alt">
          );
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
         </li>
         <li class="">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * 测试挖掘频繁2-项集
          </span>
         </li>
         <li class="">
          <span class="comment">
           */
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           void
          </span>
          testGetFreq2ItemSet() {
         </li>
         <li class="">
          System.out.println(
         </li>
         <li class="alt">
          <span class="string">
           “挖掘频繁2-项集 ：”
          </span>
          +
         </li>
         <li class="">
          <span class="keyword">
           this
          </span>
          .apriori.getFreqKItemSet(
          <span class="number">
           2
          </span>
          ,
          <span class="keyword">
           this
          </span>
          .apriori.getFreq1ItemSet().keySet())
         </li>
         <li class="alt">
          );
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
         </li>
         <li class="">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           * 测试挖掘频繁3-项集
          </span>
         </li>
         <li class="">
          <span class="comment">
           */
          </span>
         </li>
         <li class="alt">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           void
          </span>
          testGetFreq3ItemSet() {
         </li>
         <li class="">
          System.out.println(
         </li>
         <li class="alt">
          <span class="string">
           “挖掘频繁3-项集 ：”
          </span>
          +
         </li>
         <li class="">
          <span class="keyword">
           this
          </span>
          .apriori.getFreqKItemSet(
         </li>
         <li class="alt">
          <span class="number">
           3
          </span>
          ,
         </li>
         <li class="">
          <span class="keyword">
           this
          </span>
          .apriori.getFreqKItemSet(
          <span class="number">
           2
          </span>
          ,
          <span class="keyword">
           this
          </span>
          .apriori.getFreq1ItemSet().keySet()).keySet()
         </li>
         <li class="alt">
          )
         </li>
         <li class="">
          );
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 测试挖掘全部频繁项集
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           */
          </span>
         </li>
         <li class="">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           void
          </span>
          testGetFreqItemSet() {
         </li>
         <li class="alt">
          <span class="keyword">
           this
          </span>
          .apriori.mineFreqItemSet();
          <span class="comment">
           // 挖掘频繁项集
          </span>
         </li>
         <li class="">
          System.out.println(
          <span class="string">
           “挖掘频繁项集 ：”
          </span>
          +
          <span class="keyword">
           this
          </span>
          .apriori.getFreqItemSet());
         </li>
         <li class="alt">
          }
         </li>
         <li class="">
         </li>
         <li class="alt">
          <span class="comment">
           /**
          </span>
         </li>
         <li class="">
          <span class="comment">
           * 测试挖掘全部频繁关联规则
          </span>
         </li>
         <li class="alt">
          <span class="comment">
           */
          </span>
         </li>
         <li class="">
          <span class="keyword">
           public
          </span>
          <span class="keyword">
           void
          </span>
          testMineAssociationRules() {
         </li>
         <li class="alt">
          <span class="keyword">
           this
          </span>
          .apriori.mineFreqItemSet();
          <span class="comment">
           // 挖掘频繁项集
          </span>
         </li>
         <li class="">
          <span class="keyword">
           this
          </span>
          .apriori.mineAssociationRules();
         </li>
         <li class="alt">
          System.out.println(
          <span class="string">
           “挖掘频繁关联规则 ：”
          </span>
          +
          <span class="keyword">
           this
          </span>
          .apriori.getAssiciationRules());
         </li>
         <li class="">
          }
         </li>
         <li class="alt">
          }
         </li>
        </ol>
       </div>
       <p>
        参考：
        <a href="http://hi.baidu.com/shirdrn/item/5b74a313d55256711009b5d8" target="_blank">
         http://hi.baidu.com/shirdrn/item/5b74a313d55256711009b5d8
        </a>
       </p>
       <p>
        在此基础上添加了has_infrequent_subset方法，此方法使用先验知识进行剪枝，是典型Apriori算法必备的。
       </p>
       <p>
       </p>
       <blockquote>
        <p>
         文章整合自：
        </p>
        <p>
         <a class="user_name" href="http://my.csdn.net/sealyao" target="_blank">
          sealyao
         </a>
         的博客文章：
         <a href="http://blog.csdn.net/sealyao/article/details/6460578">
          关联挖掘算法Apriori和FP-Tree学习
         </a>
        </p>
        <p>
         <a class="user_name" href="http://my.csdn.net/kingzone_2008" target="_blank">
          kingzone_2008
         </a>
         的博客文章：
         <a href="http://blog.csdn.net/kingzone_2008/article/details/17127567">
          Apriori算法实现
         </a>
        </p>
       </blockquote>
      </div>
      <div>
       <strong>
        注：转载文章均来自于公开网络，仅供学习使用，不会用于任何商业用途，如果侵犯到原作者的权益，请您与我们联系删除或者授权事宜，联系邮箱：contact@dataunion.org。转载数盟网站文章请注明原文章作者，否则产生的任何版权纠纷与数盟无关。
       </strong>
      </div>
      <!--content_text-->
      <div class="fenxian">
       <!-- JiaThis Button BEGIN -->
       <div class="jiathis_style_32x32">
        <p class="jiathis_button_weixin">
        </p>
        <p class="jiathis_button_tsina">
        </p>
        <p class="jiathis_button_qzone">
        </p>
        <p class="jiathis_button_cqq">
        </p>
        <p class="jiathis_button_tumblr">
        </p>
        <a class="jiathis jiathis_txt jtico jtico_jiathis" href="http://www.jiathis.com/share" target="_blank">
        </a>
        <p class="jiathis_counter_style">
        </p>
       </div>
       <!-- JiaThis Button END -->
      </div>
     </article>
     <!--content-->
     <!--相关文章-->
     <div class="xianguan">
      <div class="xianguantitle">
       相关文章！
      </div>
      <ul class="pic">
       <li>
        <a href="http://dataunion.org/24220.html">
         <img src="http://dataunion.org/wp-content/uploads/2016/05/100910rrxp5plglxk4lcle-291x200.png"/>
        </a>
        <a class="link" href="http://dataunion.org/24220.html" rel="bookmark" title="520大数据：八成男性期待被表白 “套路”也是爱">
         520大数据：八成男性期待被表白 “套路”也是爱
        </a>
       </li>
       <li>
        <a href="http://dataunion.org/23785.html">
         <img src="http://dataunion.org/wp-content/uploads/2016/04/u7145986293872240263fm21gp0-298x200.jpg"/>
        </a>
        <a class="link" href="http://dataunion.org/23785.html" rel="bookmark" title="Docker安全基准：22项新增要点概述">
         Docker安全基准：22项新增要点概述
        </a>
       </li>
       <li>
        <a href="http://dataunion.org/23703.html">
         <img src="http://dataunion.org/wp-content/uploads/2016/04/1317020-300x163.jpg"/>
        </a>
        <a class="link" href="http://dataunion.org/23703.html" rel="bookmark" title="推荐：五个不容错过的数据科学家博客">
         推荐：五个不容错过的数据科学家博客
        </a>
       </li>
       <li>
        <a href="http://dataunion.org/23507.html">
         <img src="http://dataunion.org/wp-content/uploads/2016/03/110606wjpugdldig4idddn.jpg"/>
        </a>
        <a class="link" href="http://dataunion.org/23507.html" rel="bookmark" title="解密深度学习在智能推荐系统的实践与应用">
         解密深度学习在智能推荐系统的实践与应用
        </a>
       </li>
      </ul>
     </div>
     <!--相关文章-->
     <div class="comment" id="comments">
      <!-- You can start editing here. -->
      <!-- If comments are open, but there are no comments. -->
      <div class="title">
       期待你一针见血的评论，Come on！
      </div>
      <div id="respond">
       <p>
        不用想啦，马上
        <a href="http://dataunion.org/wp-login.php?redirect_to=http%3A%2F%2Fdataunion.org%2F16342.html">
         "登录"
        </a>
        发表自已的想法.
       </p>
      </div>
     </div>
     <!-- .nav-single -->
    </div>
    <!--Container End-->
    <aside id="sitebar">
     <div class="sitebar_list2">
      <div class="wptag">
       <span class="tagtitle">
        热门标签+
       </span>
       <div class="tagg">
        <ul class="menu" id="menu-%e5%8f%8b%e6%83%85%e9%93%be%e6%8e%a5">
         <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-1605" id="menu-item-1605">
          <a href="http://taidizh.com/">
           泰迪智慧
          </a>
         </li>
         <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-20884" id="menu-item-20884">
          <a href="http://www.transwarp.cn/">
           星环科技
          </a>
         </li>
         <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-3538" id="menu-item-3538">
          <a href="http://datall.org/">
           珈和遥感
          </a>
         </li>
         <li class="menu-item menu-item-type-custom menu-item-object-custom menu-item-20888" id="menu-item-20888">
          <a href="http://www.chinahadoop.cn/">
           小象学院
          </a>
         </li>
        </ul>
       </div>
      </div>
     </div>
     <div class="sitebar_list">
      <div class="textwidget">
       <div align="center">
        <a href="http://study.163.com/course/courseMain.htm?courseId=991022" target="_blank">
         <img src="http://dataunion.org/wp-content/uploads/2016/03/dv.jpg"/>
        </a>
       </div>
      </div>
     </div>
     <div class="sitebar_list">
      <h4 class="sitebar_title">
       文章分类
      </h4>
      <div class="tagcloud">
       <a class="tag-link-44" href="http://dataunion.org/category/industry/demo" style="font-size: 10.204724409449pt;" title="4个话题">
        Demo展示
       </a>
       <a class="tag-link-31" href="http://dataunion.org/category/experts" style="font-size: 15.826771653543pt;" title="52个话题">
        专家团队
       </a>
       <a class="tag-link-870" href="http://dataunion.org/category/tech/ai" style="font-size: 19.795275590551pt;" title="273个话题">
        人工智能
       </a>
       <a class="tag-link-488" href="http://dataunion.org/category/%e5%8a%a0%e5%85%a5%e6%95%b0%e7%9b%9f" style="font-size: 8pt;" title="1个话题">
        加入数盟
       </a>
       <a class="tag-link-869" href="http://dataunion.org/category/tech/viz" style="font-size: 17.204724409449pt;" title="93个话题">
        可视化
       </a>
       <a class="tag-link-30" href="http://dataunion.org/category/partners" style="font-size: 10.645669291339pt;" title="5个话题">
        合作伙伴
       </a>
       <a class="tag-link-889" href="http://dataunion.org/category/parterc" style="font-size: 11.582677165354pt;" title="8个话题">
        合作会议
       </a>
       <a class="tag-link-104" href="http://dataunion.org/category/books" style="font-size: 12.96062992126pt;" title="15个话题">
        图书
       </a>
       <a class="tag-link-220" href="http://dataunion.org/category/tech/base" style="font-size: 19.850393700787pt;" title="281个话题">
        基础架构
       </a>
       <a class="tag-link-219" href="http://dataunion.org/category/tech/analysis" style="font-size: 19.409448818898pt;" title="232个话题">
        数据分析
       </a>
       <a class="tag-link-887" href="http://dataunion.org/category/tech/dm" style="font-size: 13.291338582677pt;" title="17个话题">
        数据挖掘
       </a>
       <a class="tag-link-34" href="http://dataunion.org/category/tech" style="font-size: 20.732283464567pt;" title="404个话题">
        文章
       </a>
       <a class="tag-link-1" href="http://dataunion.org/category/uncategorized" style="font-size: 22pt;" title="693个话题">
        未分类
       </a>
       <a class="tag-link-4" href="http://dataunion.org/category/events" style="font-size: 14.503937007874pt;" title="29个话题">
        活动
       </a>
       <a class="tag-link-890" href="http://dataunion.org/category/tech/%e6%b7%b1%e5%ba%a6%e5%ad%a6%e4%b9%a0" style="font-size: 10.204724409449pt;" title="4个话题">
        深度学习
       </a>
       <a class="tag-link-221" href="http://dataunion.org/category/tech/devl" style="font-size: 18.968503937008pt;" title="193个话题">
        编程语言
       </a>
       <a class="tag-link-888" href="http://dataunion.org/category/career" style="font-size: 15.661417322835pt;" title="48个话题">
        职业规划
       </a>
       <a class="tag-link-5" href="http://dataunion.org/category/jobs" style="font-size: 14.11811023622pt;" title="25个话题">
        职位
       </a>
       <a class="tag-link-871" href="http://dataunion.org/category/industry" style="font-size: 15.716535433071pt;" title="49个话题">
        行业
       </a>
       <a class="tag-link-613" href="http://dataunion.org/category/industry/case" style="font-size: 16.984251968504pt;" title="84个话题">
        行业应用
       </a>
       <a class="tag-link-885" href="http://dataunion.org/category/industry/news" style="font-size: 17.425196850394pt;" title="102个话题">
        行业资讯
       </a>
       <a class="tag-link-10" href="http://dataunion.org/category/training" style="font-size: 14.228346456693pt;" title="26个话题">
        课程
       </a>
       <a class="tag-link-16" href="http://dataunion.org/category/sources" style="font-size: 15.661417322835pt;" title="48个话题">
        资源
       </a>
      </div>
     </div>
     <div class="sitebar_list">
      <h4 class="sitebar_title">
       功能
      </h4>
      <ul>
       <li>
        <a href="http://dataunion.org/wp-login.php?action=register">
         注册
        </a>
       </li>
       <li>
        <a href="http://dataunion.org/wp-login.php">
         登录
        </a>
       </li>
       <li>
        <a href="http://dataunion.org/feed">
         文章
         <abbr title="Really Simple Syndication">
          RSS
         </abbr>
        </a>
       </li>
       <li>
        <a href="http://dataunion.org/comments/feed">
         评论
         <abbr title="Really Simple Syndication">
          RSS
         </abbr>
        </a>
       </li>
       <li>
        <a href="https://cn.wordpress.org/" title="基于WordPress，一个优美、先进的个人信息发布平台。">
         WordPress.org
        </a>
       </li>
      </ul>
     </div>
    </aside>
    <div class="clear">
    </div>
   </div>
   <!--main-->
   ﻿
   <footer id="dibu">
    <div class="about">
     <div class="right">
      <ul class="menu" id="menu-%e5%ba%95%e9%83%a8%e8%8f%9c%e5%8d%95">
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-18024" id="menu-item-18024">
        <a href="http://dataunion.org/category/partners">
         合作伙伴
        </a>
       </li>
       <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-20881" id="menu-item-20881">
        <a href="http://dataunion.org/contribute">
         文章投稿
        </a>
       </li>
       <li class="menu-item menu-item-type-taxonomy menu-item-object-category menu-item-20872" id="menu-item-20872">
        <a href="http://dataunion.org/category/%e5%8a%a0%e5%85%a5%e6%95%b0%e7%9b%9f">
         加入数盟
        </a>
       </li>
       <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-22441" id="menu-item-22441">
        <a href="http://dataunion.org/f-links">
         友情链接
        </a>
       </li>
       <li class="menu-item menu-item-type-post_type menu-item-object-page menu-item-20874" id="menu-item-20874">
        <a href="http://dataunion.org/aboutus">
         关于数盟
        </a>
       </li>
      </ul>
      <p class="banquan">
       数盟社区        ，
        做最棒的数据科学社区
      </p>
     </div>
     <div class="left">
      <ul class="bottomlist">
       <li>
        <a href="http://weibo.com/DataScientistUnion  " target="_blank" 　title="">
         <img src="http://dataunion.org/wp-content/themes/yzipi/images/weibo.png"/>
        </a>
       </li>
       <li>
        <a class="cd-popup-trigger" href="http://dataunion.org/16342.html#0">
         <img src="http://dataunion.org/wp-content/themes/yzipi/images/weixin.png"/>
        </a>
       </li>
      </ul>
      <div class="cd-popup">
       <div class="cd-popup-container">
        <h1>
         扫描二维码,加微信公众号
        </h1>
        <img src="http://dataunion.org/wp-content/themes/yzipi/images/2014-12-06-1515289049.png"/>
        <a class="cd-popup-close" href="http://dataunion.org/16342.html">
        </a>
       </div>
       <!-- cd-popup-container -->
      </div>
      <!-- cd-popup -->
     </div>
    </div>
    <!--about-->
    <div class="bottom">
     <a href="http://dataunion.org/">
      数盟社区
     </a>
     <a href="http://www.miitbeian.gov.cn/" rel="external nofollow" target="_blank">
      京ICP备14026740号
     </a>
     联系我们：
     <a href="mailto:contact@dataunion.org" target="_blank">
      contact@dataunion.org
     </a>
     <div class="tongji">
     </div>
     <!--bottom-->
     <div class="scroll" id="scroll" style="display:none;">
      ︿
     </div>
    </div>
   </footer>
   <!--dibu-->
  </div>
 </body>
</html>